package com.example.Service.impl;

import com.example.Mapper.MouduleMapper;
import com.example.Mapper.UsersMapper;
import com.example.Service.MenuService;
import com.example.entity.vo.MoudleVo;
import com.example.entity.vo.UsersVo;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.example.entity.Module;

import java.util.*;
import java.util.stream.Collectors;
import com.example.entity.Module;
import org.springframework.web.bind.annotation.RequestBody;

@Service
public  class MenuImpl implements MenuService {
    @Autowired
    MouduleMapper mouduleMapper;
    @Override
    public List<Module> selectById(Integer userId) {
        return mouduleMapper.selectAll(userId);
    }

    @Override
    public PageInfo<Module> selectAllByPage(MoudleVo moudleVo) {

        if(moudleVo.getPageNum() !=null && moudleVo.getPageSize()!=null){
            PageHelper.startPage(moudleVo.getPageNum(),moudleVo.getPageSize());
        }
        List<Module>  ms= mouduleMapper.selectAllByPage(moudleVo);
        return  new PageInfo<>(ms);
    }

    @Override
    public int insert(Module module) {
        return mouduleMapper.insert(module);
    }

    @Override
    public int update(Module module) {
        return mouduleMapper.update(module);
    }

    @Override
    public int deletById(Integer moduleId) {
        return mouduleMapper.deletById(moduleId);
    }

    /* 完整的层级菜单构建方法
     * @param flatModules 扁平菜单列表
     * @return 完整的菜单树
     */
    public List<Map<String, Object>> buildCompleteMenuTree(List<Module> flatModules) {
        // 1. 按parentId分组建立快速查找
        Map<Integer, List<Module>> menuByParent = flatModules.stream()
                .collect(Collectors.groupingBy(module ->
                        module.getParentId() == null ? 0 : module.getParentId()));

        // 2. 找出所有需要显示的菜单ID（包括所有父菜单和叶子菜单）
        Set<Integer> allMenuIds = flatModules.stream()
                .map(Module::getModuleId)
                .collect(Collectors.toSet());

        // 3. 构建完整的菜单树
        return buildTree(0, menuByParent, allMenuIds);
    }

    /**
     * 递归构建菜单树
     * @param parentId 当前父ID
     * @param menuByParent 按父ID分组的菜单数据
     * @param allMenuIds 所有有效菜单ID集合
     */
    private List<Map<String, Object>> buildTree(Integer parentId,
                                                Map<Integer, List<Module>> menuByParent,
                                                Set<Integer> allMenuIds) {
        return menuByParent.getOrDefault(parentId, Collections.emptyList())
                .stream()
                .filter(module -> allMenuIds.contains(module.getModuleId())) // 确保菜单有效
                .map(module -> {
                    Map<String, Object> node = convertToMap(module);
                    // 递归构建子菜单
                    List<Map<String, Object>> children = buildTree(module.getModuleId(), menuByParent, allMenuIds);
                    if (!children.isEmpty()) {
                        node.put("children", children);
                    }
                    return node;
                })
                .sorted(Comparator.comparingInt(node -> (Integer) node.get("order"))) // 按order排序
                .collect(Collectors.toList());
    }

    // 转换方法保持不变
    private Map<String, Object> convertToMap(Module module) {
        Map<String, Object> map = new LinkedHashMap<>();
        map.put("id", module.getModuleId());
        map.put("parentId", module.getParentId());
        map.put("name", module.getModuleName());
        map.put("icon", module.getModuleIcon());
        map.put("path", module.getModuleUrl());
        map.put("order", module.getModuleOrder());
        return map;
    }
}